< Summary

Class:GDX.Tables.StableTable
Assembly:GDX
File(s):D:/BuildAgent/work/GDX-Documentation/Projects/GDX_Development/Packages/com.dotbunny.gdx/GDX/Tables/StableTable.cs
Covered lines:0
Uncovered lines:801
Coverable lines:801
Total lines:1316
Line coverage:0% (0 of 801)
Covered branches:0
Total branches:0
Covered methods:0
Total methods:141
Method coverage:0% (0 of 141)

Coverage History

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
StableTable()0%2100%
GetDataVersion()0%2100%
GetColumnCount()0%2100%
GetRowCount()0%2100%
GetAllRowDescriptions()0%6200%
GetRowDescription(...)0%2100%
GetRowDescription(...)0%2100%
GetColumnDescription(...)0%2100%
GetColumnDescription(...)0%2100%
GetAllColumnDescriptions()0%42600%
SetColumnName(...)0%2100%
AddRow(...)0%30500%
AddRows(...)0%90900%
RemoveRow(...)0%6200%
RemoveRows(...)0%6200%
AddColumn(...)0%9923100%
RemoveColumn(...)0%9303000%
SetString(...)0%2100%
SetBool(...)0%2100%
SetChar(...)0%2100%
SetSByte(...)0%2100%
SetByte(...)0%2100%
SetShort(...)0%2100%
SetUShort(...)0%2100%
SetInt(...)0%2100%
SetUInt(...)0%2100%
SetLong(...)0%2100%
SetULong(...)0%2100%
SetFloat(...)0%2100%
SetDouble(...)0%2100%
SetVector2(...)0%2100%
SetVector3(...)0%2100%
SetVector4(...)0%2100%
SetVector2Int(...)0%2100%
SetVector3Int(...)0%2100%
SetQuaternion(...)0%2100%
SetRect(...)0%2100%
SetRectInt(...)0%2100%
SetColor(...)0%2100%
SetLayerMask(...)0%2100%
SetBounds(...)0%2100%
SetBoundsInt(...)0%2100%
SetHash128(...)0%2100%
SetGradient(...)0%2100%
SetAnimationCurve(...)0%2100%
SetObject(...)0%2100%
GetString(...)0%2100%
GetBool(...)0%2100%
GetChar(...)0%2100%
GetSByte(...)0%2100%
GetByte(...)0%2100%
GetShort(...)0%2100%
GetUShort(...)0%2100%
GetInt(...)0%2100%
GetUInt(...)0%2100%
GetLong(...)0%2100%
GetULong(...)0%2100%
GetFloat(...)0%2100%
GetDouble(...)0%2100%
GetVector2(...)0%2100%
GetVector3(...)0%2100%
GetVector4(...)0%2100%
GetVector2Int(...)0%2100%
GetVector3Int(...)0%2100%
GetQuaternion(...)0%2100%
GetRect(...)0%2100%
GetRectInt(...)0%2100%
GetColor(...)0%2100%
GetLayerMask(...)0%2100%
GetBounds(...)0%2100%
GetBoundsInt(...)0%2100%
GetHash128(...)0%2100%
GetGradient(...)0%2100%
GetAnimationCurve(...)0%2100%
GetObject(...)0%2100%
GetStringRef(...)0%2100%
GetBoolRef(...)0%2100%
GetCharRef(...)0%2100%
GetSbyteRef(...)0%2100%
GetByteRef(...)0%2100%
GetShortRef(...)0%2100%
GetUshortRef(...)0%2100%
GetIntRef(...)0%2100%
GetUintRef(...)0%2100%
GetLongRef(...)0%2100%
GetUlongRef(...)0%2100%
GetFloatRef(...)0%2100%
GetDoubleRef(...)0%2100%
GetVector2Ref(...)0%2100%
GetVector3Ref(...)0%2100%
GetVector4Ref(...)0%2100%
GetVector2IntRef(...)0%2100%
GetVector3IntRef(...)0%2100%
GetQuaternionRef(...)0%2100%
GetRectRef(...)0%2100%
GetRectIntRef(...)0%2100%
GetColorRef(...)0%2100%
GetLayerMaskRef(...)0%2100%
GetBoundsRef(...)0%2100%
GetBoundsIntRef(...)0%2100%
GetHash128Ref(...)0%2100%
GetGradientRef(...)0%2100%
GetAnimationCurveRef(...)0%2100%
GetObjectRef(...)0%2100%
GetStringColumn(...)0%2100%
GetBoolColumn(...)0%2100%
GetCharColumn(...)0%2100%
GetSbyteColumn(...)0%2100%
GetByteColumn(...)0%2100%
GetShortColumn(...)0%2100%
GetUshortColumn(...)0%2100%
GetIntColumn(...)0%2100%
GetUintColumn(...)0%2100%
GetLongColumn(...)0%2100%
GetUlongColumn(...)0%2100%
GetFloatColumn(...)0%2100%
GetDoubleColumn(...)0%2100%
GetVector2Column(...)0%2100%
GetVector3Column(...)0%2100%
GetVector4Column(...)0%2100%
GetVector2IntColumn(...)0%2100%
GetVector3IntColumn(...)0%2100%
GetQuaternionColumn(...)0%2100%
GetRectColumn(...)0%2100%
GetRectIntColumn(...)0%2100%
GetColorColumn(...)0%2100%
GetLayerMaskColumn(...)0%2100%
GetBoundsColumn(...)0%2100%
GetBoundsIntColumn(...)0%2100%
GetHash128Column(...)0%2100%
GetGradientColumn(...)0%2100%
GetAnimationCurveColumn(...)0%2100%
GetObjectColumn(...)0%2100%
AddColumnInternal[T](...)0%5062200%
RemoveColumnInternal[T](...)0%20400%
InsertRowsOfTypeInternal[T](...)0%42600%
DeleteRowsOfTypeInternal[T](...)0%30500%
GetCellRef[T](...)0%2100%
GetCell[T](...)0%2100%
SetCell[T](...)0%2100%
GetColumn[T](...)0%2100%

File(s)

D:/BuildAgent/work/GDX-Documentation/Projects/GDX_Development/Packages/com.dotbunny.gdx/GDX/Tables/StableTable.cs

#LineLine coverage
 1// Copyright (c) 2020-2023 dotBunny Inc.
 2// dotBunny licenses this file to you under the BSL-1.0 license.
 3// See the LICENSE file in the project root for more information.
 4
 5using System;
 6using GDX.Collections;
 7using UnityEngine;
 8
 9namespace GDX.Tables
 10{
 11
 12    [CreateAssetMenu(menuName = "GDX/Stable Table", fileName = "GDXStableTable")]
 13    [Serializable]
 14    public class StableTable : ScriptableObject, ITable
 15    {
 16        [Serializable]
 17        internal struct ColumnEntry
 18        {
 19            public Serializable.SerializableTypes ColumnType;
 20            public int columnDenseIndex;
 21        }
 22
 23        [SerializeField] internal ArrayHolder<string>[] allStringColumns;
 24        [SerializeField] internal ArrayHolder<bool>[] allBoolColumns;
 25        [SerializeField] internal ArrayHolder<char>[] allCharColumns;
 26        [SerializeField] internal ArrayHolder<sbyte>[] allSbyteColumns;
 27        [SerializeField] internal ArrayHolder<byte>[] allByteColumns;
 28        [SerializeField] internal ArrayHolder<short>[] allShortColumns;
 29        [SerializeField] internal ArrayHolder<ushort>[] allUshortColumns;
 30        [SerializeField] internal ArrayHolder<int>[] allIntColumns;
 31        [SerializeField] internal ArrayHolder<uint>[] allUintColumns;
 32        [SerializeField] internal ArrayHolder<long>[] allLongColumns;
 33        [SerializeField] internal ArrayHolder<ulong>[] allUlongColumns;
 34        [SerializeField] internal ArrayHolder<float>[] allFloatColumns;
 35        [SerializeField] internal ArrayHolder<double>[] allDoubleColumns;
 36        [SerializeField] internal ArrayHolder<Vector2>[] allVector2Columns;
 37        [SerializeField] internal ArrayHolder<Vector3>[] allVector3Columns;
 38        [SerializeField] internal ArrayHolder<Vector4>[] allVector4Columns;
 39        [SerializeField] internal ArrayHolder<Vector2Int>[] allVector2IntColumns;
 40        [SerializeField] internal ArrayHolder<Vector3Int>[] allVector3IntColumns;
 41        [SerializeField] internal ArrayHolder<Quaternion>[] allQuaternionColumns;
 42        [SerializeField] internal ArrayHolder<Rect>[] allRectColumns;
 43        [SerializeField] internal ArrayHolder<RectInt>[] allRectIntColumns;
 44        [SerializeField] internal ArrayHolder<Color>[] allColorColumns;
 45        [SerializeField] internal ArrayHolder<LayerMask>[] allLayerMaskColumns;
 46        [SerializeField] internal ArrayHolder<Bounds>[] allBoundsColumns;
 47        [SerializeField] internal ArrayHolder<BoundsInt>[] allBoundsIntColumns;
 48        [SerializeField] internal ArrayHolder<Hash128>[] allHash128Columns;
 49        [SerializeField] internal ArrayHolder<Gradient>[] allGradientColumns;
 50        [SerializeField] internal ArrayHolder<AnimationCurve>[] allAnimationCurveColumns;
 51        [SerializeField] internal ArrayHolder<UnityEngine.Object>[] allObjectRefColumns;
 052        [SerializeField] internal ArrayHolder<string>[] allColumnNames = new ArrayHolder<string>[Serializable.Serializab
 053        [SerializeField] internal ArrayHolder<int>[] allColumnOrders = new ArrayHolder<int>[Serializable.SerializableTyp
 54
 55
 56        [SerializeField] internal string[] allRowNames;
 57        [SerializeField] internal int[] rowIDToDenseIndexMap;
 58        [SerializeField] internal int[] rowDenseIndexToIDMap;
 59        [SerializeField] internal int rowEntriesFreeListHead;
 60
 61
 62        [SerializeField]
 63        internal int rowCount;
 64
 65        [SerializeField]
 66        internal ColumnEntry[] columnIDToDenseIndexMap;
 67
 68        // TODO move with other block
 069        [SerializeField] ArrayHolder<int>[] columnDenseIndexToIDMap = new ArrayHolder<int>[Serializable.SerializableType
 70
 71        [SerializeField]
 72        internal int columnEntriesFreeListHead;
 73
 74        [SerializeField]
 75        internal int combinedColumnCount;
 76
 77        [SerializeField]
 078        internal ulong dataVersion = 1;
 79
 80
 81        public ulong GetDataVersion()
 082        {
 083            return dataVersion;
 084        }
 85
 86        /// <inheritdoc />
 87        public int GetColumnCount()
 088        {
 089            return combinedColumnCount;
 090        }
 91
 92        /// <inheritdoc />
 93        public int GetRowCount()
 094        {
 095            return rowCount;
 096        }
 97
 98        public ITable.RowDescription[] GetAllRowDescriptions()
 099        {
 0100            if (combinedColumnCount == 0) return null;
 0101            ITable.RowDescription[] returnArray = new ITable.RowDescription[rowCount];
 102
 103            // TODO: populate with stable etc
 104
 0105            return returnArray;
 0106        }
 107        public ITable.RowDescription GetRowDescription(string name)
 0108        {
 0109            throw new NotImplementedException();
 110        }
 111
 112        public ITable.RowDescription GetRowDescription(int order)
 0113        {
 0114            throw new NotImplementedException();
 115        }
 116
 117        public ITable.ColumnDescription GetColumnDescription(string name)
 0118        {
 0119            throw new NotImplementedException();
 120        }
 121
 122        public ITable.ColumnDescription GetColumnDescription(int order)
 0123        {
 0124            throw new NotImplementedException();
 125        }
 126
 127        /// <inheritdoc />
 128        public ITable.ColumnDescription[] GetAllColumnDescriptions()
 0129        {
 0130            if (combinedColumnCount == 0) return null;
 0131            ITable.ColumnDescription[] returnArray = new ITable.ColumnDescription[combinedColumnCount];
 132
 0133            for (int columnIndex = 0; columnIndex < Serializable.SerializableTypesCount; columnIndex++)
 0134            {
 135
 0136                int[] columnOrders = allColumnOrders[columnIndex].TArray;
 0137                int columnOrdersLength = columnOrders?.Length ?? 0;
 138
 0139                int[] columnIndices = columnDenseIndexToIDMap[columnIndex].TArray;
 0140                string[] columnNames = allColumnNames[columnIndex].TArray;
 141
 0142                for (int i = 0; i < columnOrdersLength; i++)
 0143                {
 0144                    returnArray[columnOrders[i]] = new ITable.ColumnDescription
 145                    {
 146                        Name =  columnNames[i],
 147                        Index = columnIndices[i],
 148                        Type = (Serializable.SerializableTypes)columnIndex
 149                    };
 0150                }
 0151            }
 0152            return returnArray;
 0153        }
 154
 155        public void SetColumnName(string name, int column)
 0156        {
 0157            throw new NotImplementedException();
 158            // TODO: Way to set column name
 159        }
 160
 161
 162
 163
 164
 165        public void AddRow(string rowName = null, int insertAt = -1)
 0166        {
 167            // TODO: For adam to do
 168            // int rowIndex = rowEntriesFreeListHead;
 169            // int rowIDToDenseIndexMapLength = rowIDToDenseIndexMap?.Length ?? 0;
 170            // if (rowIndex >= rowIDToDenseIndexMapLength)
 171            // {
 172            //     int newSize = rowIndex * 2;
 173            //     newSize = newSize == 0 ? 1 : newSize;
 174            //     Array.Resize(ref rowIDToDenseIndexMap, newSize);
 175            //     for (int i = 0; i < rowIndex; i++)
 176            //     {
 177            //         rowIDToDenseIndexMap[rowIndex + i] = rowIndex + i + 1;
 178            //     }
 179            // }
 180            // int denseIndexToIDMapLength = rowDenseIndexToIDMap?.Length ?? 0;
 181            // Array.Resize(ref rowDenseIndexToIDMap, denseIndexToIDMapLength + 1);
 182            //
 183            //
 184            // rowDenseIndexToIDMap[denseIndexToIDMapLength] = rowIndex;
 185
 186
 0187            insertAt = insertAt < 0 ? rowCount : insertAt;
 188
 0189            Array.Resize(ref allRowNames, rowCount + 1);
 0190            for (int i = rowCount; i > insertAt; i--)
 0191            {
 0192                allRowNames[i] = allRowNames[i - 1];
 0193            }
 194
 0195            rowName ??= string.Empty;
 0196            allRowNames[insertAt] = rowName;
 197
 0198            InsertRowsOfTypeInternal(ref allStringColumns, insertAt, 1);
 0199            InsertRowsOfTypeInternal(ref allBoolColumns, insertAt, 1);
 0200            InsertRowsOfTypeInternal(ref allCharColumns, insertAt, 1);
 0201            InsertRowsOfTypeInternal(ref allSbyteColumns, insertAt, 1);
 0202            InsertRowsOfTypeInternal(ref allByteColumns, insertAt, 1);
 0203            InsertRowsOfTypeInternal(ref allShortColumns, insertAt, 1);
 0204            InsertRowsOfTypeInternal(ref allUshortColumns, insertAt, 1);
 0205            InsertRowsOfTypeInternal(ref allIntColumns, insertAt, 1);
 0206            InsertRowsOfTypeInternal(ref allUintColumns, insertAt, 1);
 0207            InsertRowsOfTypeInternal(ref allLongColumns, insertAt, 1);
 0208            InsertRowsOfTypeInternal(ref allUlongColumns, insertAt, 1);
 0209            InsertRowsOfTypeInternal(ref allFloatColumns, insertAt, 1);
 0210            InsertRowsOfTypeInternal(ref allDoubleColumns, insertAt, 1);
 0211            InsertRowsOfTypeInternal(ref allVector2Columns, insertAt, 1);
 0212            InsertRowsOfTypeInternal(ref allVector3Columns, insertAt, 1);
 0213            InsertRowsOfTypeInternal(ref allVector4Columns, insertAt, 1);
 0214            InsertRowsOfTypeInternal(ref allVector2IntColumns, insertAt, 1);
 0215            InsertRowsOfTypeInternal(ref allVector3IntColumns, insertAt, 1);
 0216            InsertRowsOfTypeInternal(ref allQuaternionColumns, insertAt, 1);
 0217            InsertRowsOfTypeInternal(ref allRectColumns, insertAt, 1);
 0218            InsertRowsOfTypeInternal(ref allRectIntColumns, insertAt, 1);
 0219            InsertRowsOfTypeInternal(ref allColorColumns, insertAt, 1);
 0220            InsertRowsOfTypeInternal(ref allLayerMaskColumns, insertAt, 1);
 0221            InsertRowsOfTypeInternal(ref allBoundsColumns, insertAt, 1);
 0222            InsertRowsOfTypeInternal(ref allBoundsIntColumns, insertAt, 1);
 0223            InsertRowsOfTypeInternal(ref allHash128Columns, insertAt, 1);
 0224            InsertRowsOfTypeInternal(ref allGradientColumns, insertAt, 1);
 0225            InsertRowsOfTypeInternal(ref allAnimationCurveColumns, insertAt, 1);
 0226            InsertRowsOfTypeInternal(ref allObjectRefColumns, insertAt, 1);
 227
 0228            ++rowCount;
 0229            dataVersion++;
 0230        }
 231
 232        public void AddRows(int numberOfNewRows, string[] rowNames = null, int insertAt = -1)
 0233        {
 0234            insertAt = insertAt < 0 ? rowCount : insertAt;
 235
 0236            Array.Resize(ref allRowNames, rowCount + 1);
 0237            for (int i = rowCount; i > insertAt; i--)
 0238            {
 0239                allRowNames[i] = allRowNames[i - 1];
 0240            }
 241
 0242            string empty = string.Empty;
 0243            int rowNamesLength = rowNames?.Length ?? 0;
 0244            for (int i = 0; i < rowNames.Length; i++)
 0245            {
 0246                string nameAt = rowNames[i];
 0247                allRowNames[insertAt + i] = nameAt ?? empty;
 0248            }
 249
 0250            for (int i = rowNamesLength; i < numberOfNewRows; i++)
 0251            {
 0252                allRowNames[insertAt + i] = empty;
 0253            }
 254
 0255            InsertRowsOfTypeInternal(ref allStringColumns, insertAt, numberOfNewRows);
 0256            InsertRowsOfTypeInternal(ref allBoolColumns, insertAt, numberOfNewRows);
 0257            InsertRowsOfTypeInternal(ref allCharColumns, insertAt, numberOfNewRows);
 0258            InsertRowsOfTypeInternal(ref allSbyteColumns, insertAt, numberOfNewRows);
 0259            InsertRowsOfTypeInternal(ref allByteColumns, insertAt, numberOfNewRows);
 0260            InsertRowsOfTypeInternal(ref allShortColumns, insertAt, numberOfNewRows);
 0261            InsertRowsOfTypeInternal(ref allUshortColumns, insertAt, numberOfNewRows);
 0262            InsertRowsOfTypeInternal(ref allIntColumns, insertAt, numberOfNewRows);
 0263            InsertRowsOfTypeInternal(ref allUintColumns, insertAt, numberOfNewRows);
 0264            InsertRowsOfTypeInternal(ref allLongColumns, insertAt, numberOfNewRows);
 0265            InsertRowsOfTypeInternal(ref allUlongColumns, insertAt, numberOfNewRows);
 0266            InsertRowsOfTypeInternal(ref allFloatColumns, insertAt, numberOfNewRows);
 0267            InsertRowsOfTypeInternal(ref allDoubleColumns, insertAt, numberOfNewRows);
 0268            InsertRowsOfTypeInternal(ref allVector2Columns, insertAt, numberOfNewRows);
 0269            InsertRowsOfTypeInternal(ref allVector3Columns, insertAt, numberOfNewRows);
 0270            InsertRowsOfTypeInternal(ref allVector4Columns, insertAt, numberOfNewRows);
 0271            InsertRowsOfTypeInternal(ref allVector2IntColumns, insertAt, numberOfNewRows);
 0272            InsertRowsOfTypeInternal(ref allVector3IntColumns, insertAt, numberOfNewRows);
 0273            InsertRowsOfTypeInternal(ref allQuaternionColumns, insertAt, numberOfNewRows);
 0274            InsertRowsOfTypeInternal(ref allRectColumns, insertAt, numberOfNewRows);
 0275            InsertRowsOfTypeInternal(ref allRectIntColumns, insertAt, numberOfNewRows);
 0276            InsertRowsOfTypeInternal(ref allColorColumns, insertAt, numberOfNewRows);
 0277            InsertRowsOfTypeInternal(ref allLayerMaskColumns, insertAt, numberOfNewRows);
 0278            InsertRowsOfTypeInternal(ref allBoundsColumns, insertAt, numberOfNewRows);
 0279            InsertRowsOfTypeInternal(ref allBoundsIntColumns, insertAt, numberOfNewRows);
 0280            InsertRowsOfTypeInternal(ref allHash128Columns, insertAt, numberOfNewRows);
 0281            InsertRowsOfTypeInternal(ref allGradientColumns, insertAt, numberOfNewRows);
 0282            InsertRowsOfTypeInternal(ref allAnimationCurveColumns, insertAt, numberOfNewRows);
 0283            InsertRowsOfTypeInternal(ref allObjectRefColumns, insertAt, numberOfNewRows);
 284
 0285            rowCount += numberOfNewRows;
 0286            dataVersion++;
 0287        }
 288
 289        public void RemoveRow(int removeAt)
 0290        {
 0291            int newRowCount = rowCount - 1;
 0292            for (int j = removeAt; j < newRowCount; j++)
 0293            {
 0294                allRowNames[j] = allRowNames[j + 1];
 0295            }
 296
 0297            Array.Resize(ref allRowNames, newRowCount);
 298
 0299            DeleteRowsOfTypeInternal(ref allStringColumns, removeAt, 1);
 0300            DeleteRowsOfTypeInternal(ref allBoolColumns, removeAt, 1);
 0301            DeleteRowsOfTypeInternal(ref allCharColumns, removeAt, 1);
 0302            DeleteRowsOfTypeInternal(ref allSbyteColumns, removeAt, 1);
 0303            DeleteRowsOfTypeInternal(ref allByteColumns, removeAt, 1);
 0304            DeleteRowsOfTypeInternal(ref allShortColumns, removeAt, 1);
 0305            DeleteRowsOfTypeInternal(ref allUshortColumns, removeAt, 1);
 0306            DeleteRowsOfTypeInternal(ref allIntColumns, removeAt, 1);
 0307            DeleteRowsOfTypeInternal(ref allUintColumns, removeAt, 1);
 0308            DeleteRowsOfTypeInternal(ref allLongColumns, removeAt, 1);
 0309            DeleteRowsOfTypeInternal(ref allUlongColumns, removeAt, 1);
 0310            DeleteRowsOfTypeInternal(ref allFloatColumns, removeAt, 1);
 0311            DeleteRowsOfTypeInternal(ref allDoubleColumns, removeAt, 1);
 0312            DeleteRowsOfTypeInternal(ref allVector2Columns, removeAt, 1);
 0313            DeleteRowsOfTypeInternal(ref allVector3Columns, removeAt, 1);
 0314            DeleteRowsOfTypeInternal(ref allVector4Columns, removeAt, 1);
 0315            DeleteRowsOfTypeInternal(ref allVector2IntColumns, removeAt, 1);
 0316            DeleteRowsOfTypeInternal(ref allVector3IntColumns, removeAt, 1);
 0317            DeleteRowsOfTypeInternal(ref allQuaternionColumns, removeAt, 1);
 0318            DeleteRowsOfTypeInternal(ref allRectColumns, removeAt, 1);
 0319            DeleteRowsOfTypeInternal(ref allRectIntColumns, removeAt, 1);
 0320            DeleteRowsOfTypeInternal(ref allColorColumns, removeAt, 1);
 0321            DeleteRowsOfTypeInternal(ref allLayerMaskColumns, removeAt, 1);
 0322            DeleteRowsOfTypeInternal(ref allBoundsColumns, removeAt, 1);
 0323            DeleteRowsOfTypeInternal(ref allBoundsIntColumns, removeAt, 1);
 0324            DeleteRowsOfTypeInternal(ref allHash128Columns, removeAt, 1);
 0325            DeleteRowsOfTypeInternal(ref allGradientColumns, removeAt, 1);
 0326            DeleteRowsOfTypeInternal(ref allAnimationCurveColumns, removeAt, 1);
 0327            DeleteRowsOfTypeInternal(ref allObjectRefColumns, removeAt, 1);
 328
 0329            --rowCount;
 0330            dataVersion++;
 0331        }
 332
 333        public void RemoveRows(int removeAt, int numberOfRowsToDelete)
 0334        {
 0335            int newRowCount = rowCount - numberOfRowsToDelete;
 0336            for (int j = removeAt; j < rowCount - numberOfRowsToDelete; j++)
 0337            {
 0338                allRowNames[j] = allRowNames[j + numberOfRowsToDelete];
 0339            }
 340
 0341            Array.Resize(ref allRowNames, newRowCount);
 342
 0343            DeleteRowsOfTypeInternal(ref allStringColumns, removeAt, numberOfRowsToDelete);
 0344            DeleteRowsOfTypeInternal(ref allBoolColumns, removeAt, numberOfRowsToDelete);
 0345            DeleteRowsOfTypeInternal(ref allCharColumns, removeAt, numberOfRowsToDelete);
 0346            DeleteRowsOfTypeInternal(ref allSbyteColumns, removeAt, numberOfRowsToDelete);
 0347            DeleteRowsOfTypeInternal(ref allByteColumns, removeAt, numberOfRowsToDelete);
 0348            DeleteRowsOfTypeInternal(ref allShortColumns, removeAt, numberOfRowsToDelete);
 0349            DeleteRowsOfTypeInternal(ref allUshortColumns, removeAt, numberOfRowsToDelete);
 0350            DeleteRowsOfTypeInternal(ref allIntColumns, removeAt, numberOfRowsToDelete);
 0351            DeleteRowsOfTypeInternal(ref allUintColumns, removeAt, numberOfRowsToDelete);
 0352            DeleteRowsOfTypeInternal(ref allLongColumns, removeAt, numberOfRowsToDelete);
 0353            DeleteRowsOfTypeInternal(ref allUlongColumns, removeAt, numberOfRowsToDelete);
 0354            DeleteRowsOfTypeInternal(ref allFloatColumns, removeAt, numberOfRowsToDelete);
 0355            DeleteRowsOfTypeInternal(ref allDoubleColumns, removeAt, numberOfRowsToDelete);
 0356            DeleteRowsOfTypeInternal(ref allVector2Columns, removeAt, numberOfRowsToDelete);
 0357            DeleteRowsOfTypeInternal(ref allVector3Columns, removeAt, numberOfRowsToDelete);
 0358            DeleteRowsOfTypeInternal(ref allVector4Columns, removeAt, numberOfRowsToDelete);
 0359            DeleteRowsOfTypeInternal(ref allVector2IntColumns, removeAt, numberOfRowsToDelete);
 0360            DeleteRowsOfTypeInternal(ref allVector3IntColumns, removeAt, numberOfRowsToDelete);
 0361            DeleteRowsOfTypeInternal(ref allQuaternionColumns, removeAt, numberOfRowsToDelete);
 0362            DeleteRowsOfTypeInternal(ref allRectColumns, removeAt, numberOfRowsToDelete);
 0363            DeleteRowsOfTypeInternal(ref allRectIntColumns, removeAt, numberOfRowsToDelete);
 0364            DeleteRowsOfTypeInternal(ref allColorColumns, removeAt, numberOfRowsToDelete);
 0365            DeleteRowsOfTypeInternal(ref allLayerMaskColumns, removeAt, numberOfRowsToDelete);
 0366            DeleteRowsOfTypeInternal(ref allBoundsColumns, removeAt, numberOfRowsToDelete);
 0367            DeleteRowsOfTypeInternal(ref allBoundsIntColumns, removeAt, numberOfRowsToDelete);
 0368            DeleteRowsOfTypeInternal(ref allHash128Columns, removeAt, numberOfRowsToDelete);
 0369            DeleteRowsOfTypeInternal(ref allGradientColumns, removeAt, numberOfRowsToDelete);
 0370            DeleteRowsOfTypeInternal(ref allAnimationCurveColumns, removeAt, numberOfRowsToDelete);
 0371            DeleteRowsOfTypeInternal(ref allObjectRefColumns, removeAt, numberOfRowsToDelete);
 372
 0373            rowCount -= numberOfRowsToDelete;
 0374            dataVersion++;
 0375        }
 376
 377
 378        // TODO: Need to make sure that insertAt is the stableID, also this should return the stableID of the newly crea
 379        public int AddColumn(Serializable.SerializableTypes columnType, string columnName, int insertAt = -1)
 0380        {
 0381            switch (columnType)
 382            {
 383                case Serializable.SerializableTypes.String:
 0384                    return AddColumnInternal(columnName, ref allStringColumns, Serializable.SerializableTypes.String, in
 385                case Serializable.SerializableTypes.Char:
 0386                    return AddColumnInternal(columnName, ref allCharColumns, Serializable.SerializableTypes.Char, insert
 387                case Serializable.SerializableTypes.Bool:
 0388                    return AddColumnInternal(columnName, ref allBoolColumns, Serializable.SerializableTypes.Bool, insert
 389                case Serializable.SerializableTypes.SByte:
 0390                    return AddColumnInternal(columnName, ref allSbyteColumns, Serializable.SerializableTypes.SByte, inse
 391                case Serializable.SerializableTypes.Byte:
 0392                    return AddColumnInternal(columnName, ref allByteColumns, Serializable.SerializableTypes.Byte, insert
 393                case Serializable.SerializableTypes.Short:
 0394                    return AddColumnInternal(columnName, ref allShortColumns, Serializable.SerializableTypes.Short, inse
 395                case Serializable.SerializableTypes.UShort:
 0396                    return AddColumnInternal(columnName, ref allUshortColumns, Serializable.SerializableTypes.UShort, in
 397                case Serializable.SerializableTypes.Int:
 0398                    return AddColumnInternal(columnName, ref allIntColumns, Serializable.SerializableTypes.Int, insertAt
 399                case Serializable.SerializableTypes.UInt:
 0400                    return AddColumnInternal(columnName, ref allUintColumns, Serializable.SerializableTypes.UInt, insert
 401                case Serializable.SerializableTypes.Long:
 0402                    return AddColumnInternal(columnName, ref allLongColumns, Serializable.SerializableTypes.Long, insert
 403                case Serializable.SerializableTypes.ULong:
 0404                    return AddColumnInternal(columnName, ref allUlongColumns, Serializable.SerializableTypes.ULong, inse
 405                case Serializable.SerializableTypes.Float:
 0406                    return AddColumnInternal(columnName, ref allFloatColumns, Serializable.SerializableTypes.Float, inse
 407                case Serializable.SerializableTypes.Double:
 0408                    return AddColumnInternal(columnName, ref allDoubleColumns, Serializable.SerializableTypes.Double, in
 409                case Serializable.SerializableTypes.Vector2:
 0410                    return AddColumnInternal(columnName, ref allVector2Columns, Serializable.SerializableTypes.Vector2, 
 411                case Serializable.SerializableTypes.Vector3:
 0412                    return AddColumnInternal(columnName, ref allVector3Columns, Serializable.SerializableTypes.Vector3, 
 413                case Serializable.SerializableTypes.Vector4:
 0414                    return AddColumnInternal(columnName, ref allVector4Columns, Serializable.SerializableTypes.Vector4, 
 415                case Serializable.SerializableTypes.Vector2Int:
 0416                    return AddColumnInternal(columnName, ref allVector2IntColumns, Serializable.SerializableTypes.Vector
 417                case Serializable.SerializableTypes.Vector3Int:
 0418                    return AddColumnInternal(columnName, ref allVector3IntColumns, Serializable.SerializableTypes.Vector
 419                case Serializable.SerializableTypes.Quaternion:
 0420                    return AddColumnInternal(columnName, ref allQuaternionColumns, Serializable.SerializableTypes.Quater
 421                case Serializable.SerializableTypes.Rect:
 0422                    return AddColumnInternal(columnName, ref allRectColumns, Serializable.SerializableTypes.Rect, insert
 423                case Serializable.SerializableTypes.RectInt:
 0424                    return AddColumnInternal(columnName, ref allRectIntColumns, Serializable.SerializableTypes.RectInt, 
 425                case Serializable.SerializableTypes.Color:
 0426                    return AddColumnInternal(columnName, ref allColorColumns, Serializable.SerializableTypes.Color, inse
 427                case Serializable.SerializableTypes.LayerMask:
 0428                    return AddColumnInternal(columnName, ref allLayerMaskColumns, Serializable.SerializableTypes.LayerMa
 429                case Serializable.SerializableTypes.Bounds:
 0430                    return AddColumnInternal(columnName, ref allBoundsColumns, Serializable.SerializableTypes.Bounds, in
 431                case Serializable.SerializableTypes.BoundsInt:
 0432                    return AddColumnInternal(columnName, ref allBoundsIntColumns, Serializable.SerializableTypes.BoundsI
 433                case Serializable.SerializableTypes.Hash128:
 0434                    return AddColumnInternal(columnName, ref allHash128Columns, Serializable.SerializableTypes.Hash128, 
 435                case Serializable.SerializableTypes.Gradient:
 0436                    return AddColumnInternal(columnName, ref allGradientColumns, Serializable.SerializableTypes.Gradient
 437                case Serializable.SerializableTypes.AnimationCurve:
 0438                    return AddColumnInternal(columnName, ref allAnimationCurveColumns, Serializable.SerializableTypes.An
 439                case Serializable.SerializableTypes.Object:
 0440                    return AddColumnInternal(columnName, ref allObjectRefColumns, Serializable.SerializableTypes.Object,
 441            }
 0442            return -1;
 0443        }
 444
 445        // TODO: need to make sure this is the stable ID?
 446        public void RemoveColumn(Serializable.SerializableTypes columnType, int removeAt = -1)
 0447        {
 0448            switch (columnType)
 449            {
 450                case Serializable.SerializableTypes.String:
 0451                    RemoveColumnInternal(ref allStringColumns, Serializable.SerializableTypes.String, removeAt);
 0452                    break;
 453                case Serializable.SerializableTypes.Char:
 0454                    RemoveColumnInternal(ref allCharColumns, Serializable.SerializableTypes.Char, removeAt);
 0455                    break;
 456                case Serializable.SerializableTypes.Bool:
 0457                    RemoveColumnInternal(ref allBoolColumns, Serializable.SerializableTypes.Bool, removeAt);
 0458                    break;
 459                case Serializable.SerializableTypes.SByte:
 0460                    RemoveColumnInternal(ref allSbyteColumns, Serializable.SerializableTypes.SByte, removeAt);
 0461                    break;
 462                case Serializable.SerializableTypes.Byte:
 0463                    RemoveColumnInternal(ref allByteColumns, Serializable.SerializableTypes.Byte, removeAt);
 0464                    break;
 465                case Serializable.SerializableTypes.Short:
 0466                    RemoveColumnInternal(ref allShortColumns, Serializable.SerializableTypes.Short, removeAt);
 0467                    break;
 468                case Serializable.SerializableTypes.UShort:
 0469                    RemoveColumnInternal(ref allUshortColumns, Serializable.SerializableTypes.UShort, removeAt);
 0470                    break;
 471                case Serializable.SerializableTypes.Int:
 0472                    RemoveColumnInternal(ref allIntColumns, Serializable.SerializableTypes.Int, removeAt);
 0473                    break;
 474                case Serializable.SerializableTypes.UInt:
 0475                    RemoveColumnInternal(ref allUintColumns, Serializable.SerializableTypes.UInt, removeAt);
 0476                    break;
 477                case Serializable.SerializableTypes.Long:
 0478                    RemoveColumnInternal(ref allLongColumns, Serializable.SerializableTypes.Long, removeAt);
 0479                    break;
 480                case Serializable.SerializableTypes.ULong:
 0481                    RemoveColumnInternal(ref allUlongColumns, Serializable.SerializableTypes.ULong, removeAt);
 0482                    break;
 483                case Serializable.SerializableTypes.Float:
 0484                    RemoveColumnInternal(ref allFloatColumns, Serializable.SerializableTypes.Float, removeAt);
 0485                    break;
 486                case Serializable.SerializableTypes.Double:
 0487                    RemoveColumnInternal(ref allDoubleColumns, Serializable.SerializableTypes.Double, removeAt);
 0488                    break;
 489                case Serializable.SerializableTypes.Vector2:
 0490                    RemoveColumnInternal(ref allVector2Columns, Serializable.SerializableTypes.Vector2, removeAt);
 0491                    break;
 492                case Serializable.SerializableTypes.Vector3:
 0493                    RemoveColumnInternal(ref allVector3Columns, Serializable.SerializableTypes.Vector3, removeAt);
 0494                    break;
 495                case Serializable.SerializableTypes.Vector4:
 0496                    RemoveColumnInternal(ref allVector4Columns, Serializable.SerializableTypes.Vector4, removeAt);
 0497                    break;
 498                case Serializable.SerializableTypes.Vector2Int:
 0499                    RemoveColumnInternal(ref allVector2IntColumns, Serializable.SerializableTypes.Vector2Int, removeAt);
 0500                    break;
 501                case Serializable.SerializableTypes.Vector3Int:
 0502                    RemoveColumnInternal(ref allVector3IntColumns, Serializable.SerializableTypes.Vector3Int, removeAt);
 0503                    break;
 504                case Serializable.SerializableTypes.Quaternion:
 0505                    RemoveColumnInternal(ref allQuaternionColumns, Serializable.SerializableTypes.Quaternion, removeAt);
 0506                    break;
 507                case Serializable.SerializableTypes.Rect:
 0508                    RemoveColumnInternal(ref allRectColumns, Serializable.SerializableTypes.Rect, removeAt);
 0509                    break;
 510                case Serializable.SerializableTypes.RectInt:
 0511                    RemoveColumnInternal(ref allRectIntColumns, Serializable.SerializableTypes.RectInt, removeAt);
 0512                    break;
 513                case Serializable.SerializableTypes.Color:
 0514                    RemoveColumnInternal(ref allColorColumns, Serializable.SerializableTypes.Color, removeAt);
 0515                    break;
 516                case Serializable.SerializableTypes.LayerMask:
 0517                    RemoveColumnInternal(ref allLayerMaskColumns, Serializable.SerializableTypes.LayerMask, removeAt);
 0518                    break;
 519                case Serializable.SerializableTypes.Bounds:
 0520                    RemoveColumnInternal(ref allBoundsColumns, Serializable.SerializableTypes.Bounds, removeAt);
 0521                    break;
 522                case Serializable.SerializableTypes.BoundsInt:
 0523                    RemoveColumnInternal(ref allBoundsIntColumns, Serializable.SerializableTypes.BoundsInt, removeAt);
 0524                    break;
 525                case Serializable.SerializableTypes.Hash128:
 0526                    RemoveColumnInternal(ref allHash128Columns, Serializable.SerializableTypes.Hash128, removeAt);
 0527                    break;
 528                case Serializable.SerializableTypes.Gradient:
 0529                    RemoveColumnInternal(ref allGradientColumns, Serializable.SerializableTypes.Gradient, removeAt);
 0530                    break;
 531                case Serializable.SerializableTypes.AnimationCurve:
 0532                    RemoveColumnInternal(ref allAnimationCurveColumns, Serializable.SerializableTypes.AnimationCurve, re
 0533                    break;
 534                case Serializable.SerializableTypes.Object:
 0535                    RemoveColumnInternal(ref allObjectRefColumns, Serializable.SerializableTypes.Object, removeAt);
 0536                    break;
 537            }
 0538        }
 539
 540
 541
 542
 543        // Set
 544
 545        public ulong SetString(int row, int column, string value)
 0546        {
 0547            return SetCell(row, column, ref allStringColumns, value);
 0548        }
 549
 550        public ulong SetBool(int row, int column, bool value)
 0551        {
 0552            return SetCell(row, column, ref allBoolColumns, value);
 0553        }
 554
 555        public ulong SetChar(int row, int column, char value)
 0556        {
 0557            return SetCell(row, column, ref allCharColumns, value);
 0558        }
 559
 560        public ulong SetSByte(int row, int column, sbyte value)
 0561        {
 0562            return SetCell(row, column, ref allSbyteColumns, value);
 0563        }
 564
 565        public ulong SetByte(int row, int column, byte value)
 0566        {
 0567            return SetCell(row, column, ref allByteColumns, value);
 0568        }
 569
 570        public ulong SetShort(int row, int column, short value)
 0571        {
 0572            return SetCell(row, column, ref allShortColumns, value);
 0573        }
 574
 575        public ulong SetUShort(int row, int column, ushort value)
 0576        {
 0577            return SetCell(row, column, ref allUshortColumns, value);
 0578        }
 579
 580        public ulong SetInt(int row, int column, int value)
 0581        {
 0582            return SetCell(row, column, ref allIntColumns, value);
 0583        }
 584
 585        public ulong SetUInt(int row, int column, uint value)
 0586        {
 0587            return SetCell(row, column, ref allUintColumns, value);
 0588        }
 589
 590        public ulong SetLong(int row, int column, long value)
 0591        {
 0592            return SetCell(row, column, ref allLongColumns, value);
 0593        }
 594
 595        public ulong SetULong(int row, int column, ulong value)
 0596        {
 0597            return SetCell(row, column, ref allUlongColumns, value);
 0598        }
 599
 600        public ulong SetFloat(int row, int column, float value)
 0601        {
 0602            return SetCell(row, column, ref allFloatColumns, value);
 0603        }
 604
 605        public ulong SetDouble(int row, int column, double value)
 0606        {
 0607            return SetCell(row, column, ref allDoubleColumns, value);
 0608        }
 609
 610        public ulong SetVector2(int row, int column, Vector2 value)
 0611        {
 0612            return SetCell(row, column, ref allVector2Columns, value);
 0613        }
 614
 615        public ulong SetVector3(int row, int column, Vector3 value)
 0616        {
 0617            return SetCell(row, column, ref allVector3Columns, value);
 0618        }
 619
 620        public ulong SetVector4(int row, int column, Vector4 value)
 0621        {
 0622            return SetCell(row, column, ref allVector4Columns, value);
 0623        }
 624
 625        public ulong SetVector2Int(int row, int column, Vector2Int value)
 0626        {
 0627            return SetCell(row, column, ref allVector2IntColumns, value);
 0628        }
 629
 630        public ulong SetVector3Int(int row, int column, Vector3Int value)
 0631        {
 0632            return SetCell(row, column, ref allVector3IntColumns, value);
 0633        }
 634
 635        public ulong SetQuaternion(int row, int column, Quaternion value)
 0636        {
 0637            return SetCell(row, column, ref allQuaternionColumns, value);
 0638        }
 639
 640        public ulong SetRect(int row, int column, Rect value)
 0641        {
 0642            return SetCell(row, column, ref allRectColumns, value);
 0643        }
 644
 645        public ulong SetRectInt(int row, int column, RectInt value)
 0646        {
 0647            return SetCell(row, column, ref allRectIntColumns, value);
 0648        }
 649
 650        public ulong SetColor(int row, int column, Color value)
 0651        {
 0652            return SetCell(row, column, ref allColorColumns, value);
 0653        }
 654
 655        public ulong SetLayerMask(int row, int column, LayerMask value)
 0656        {
 0657            return SetCell(row, column, ref allLayerMaskColumns, value);
 0658        }
 659
 660        public ulong SetBounds(int row, int column, Bounds value)
 0661        {
 0662            return SetCell(row, column, ref allBoundsColumns, value);
 0663        }
 664
 665        public ulong SetBoundsInt(int row, int column, BoundsInt value)
 0666        {
 0667            return SetCell(row, column, ref allBoundsIntColumns, value);
 0668        }
 669
 670        public ulong SetHash128(int row, int column, Hash128 value)
 0671        {
 0672            return SetCell(row, column, ref allHash128Columns, value);
 0673        }
 674
 675        public ulong SetGradient(int row, int column, Gradient value)
 0676        {
 0677            return SetCell(row, column, ref allGradientColumns, value);
 0678        }
 679
 680        public ulong SetAnimationCurve(int row, int column, AnimationCurve value)
 0681        {
 0682            return SetCell(row, column, ref allAnimationCurveColumns, value);
 0683        }
 684
 685        public ulong SetObject(int row, int column, UnityEngine.Object value)
 0686        {
 0687            return SetCell(row, column, ref allObjectRefColumns, value);
 0688        }
 689
 690        // Get
 691        public string GetString(int row, int column)
 0692        {
 0693            return GetCell(row, column, ref allStringColumns);
 0694        }
 695
 696        public bool GetBool(int row, int column)
 0697        {
 0698            return GetCell(row, column, ref allBoolColumns);
 0699        }
 700
 701        public char GetChar(int row, int column)
 0702        {
 0703            return GetCell(row, column, ref allCharColumns);
 0704        }
 705
 706        public sbyte GetSByte(int row, int column)
 0707        {
 0708            return GetCell(row, column, ref allSbyteColumns);
 0709        }
 710
 711        public byte GetByte(int row, int column)
 0712        {
 0713            return GetCell(row, column, ref allByteColumns);
 0714        }
 715
 716        public short GetShort(int row, int column)
 0717        {
 0718            return GetCell(row, column, ref allShortColumns);
 0719        }
 720
 721        public ushort GetUShort(int row, int column)
 0722        {
 0723            return GetCell(row, column, ref allUshortColumns);
 0724        }
 725
 726        public int GetInt(int row, int column)
 0727        {
 0728            return GetCell(row, column, ref allIntColumns);
 0729        }
 730
 731        public uint GetUInt(int row, int column)
 0732        {
 0733            return GetCell(row, column, ref allUintColumns);
 0734        }
 735
 736        public long GetLong(int row, int column)
 0737        {
 0738            return GetCell(row, column, ref allLongColumns);
 0739        }
 740
 741        public ulong GetULong(int row, int column)
 0742        {
 0743            return GetCell(row, column, ref allUlongColumns);
 0744        }
 745
 746        public float GetFloat(int row, int column)
 0747        {
 0748            return GetCell(row, column, ref allFloatColumns);
 0749        }
 750
 751        public double GetDouble(int row, int column)
 0752        {
 0753            return GetCell(row, column, ref allDoubleColumns);
 0754        }
 755
 756        public Vector2 GetVector2(int row, int column)
 0757        {
 0758            return GetCell(row, column, ref allVector2Columns);
 0759        }
 760
 761        public Vector3 GetVector3(int row, int column)
 0762        {
 0763            return GetCell(row, column, ref allVector3Columns);
 0764        }
 765
 766        public Vector4 GetVector4(int row, int column)
 0767        {
 0768            return GetCell(row, column, ref allVector4Columns);
 0769        }
 770
 771        public Vector2Int GetVector2Int(int row, int column)
 0772        {
 0773            return GetCell(row, column, ref allVector2IntColumns);
 0774        }
 775
 776        public Vector3Int GetVector3Int(int row, int column)
 0777        {
 0778            return GetCell(row, column, ref allVector3IntColumns);
 0779        }
 780
 781        public Quaternion GetQuaternion(int row, int column)
 0782        {
 0783            return GetCell(row, column, ref allQuaternionColumns);
 0784        }
 785
 786        public Rect GetRect(int row, int column)
 0787        {
 0788            return GetCell(row, column, ref allRectColumns);
 0789        }
 790
 791        public RectInt GetRectInt(int row, int column)
 0792        {
 0793            return GetCell(row, column, ref allRectIntColumns);
 0794        }
 795
 796        public Color GetColor(int row, int column)
 0797        {
 0798            return GetCell(row, column, ref allColorColumns);
 0799        }
 800
 801        public LayerMask GetLayerMask(int row, int column)
 0802        {
 0803            return GetCell(row, column, ref allLayerMaskColumns);
 0804        }
 805
 806        public Bounds GetBounds(int row, int column)
 0807        {
 0808            return GetCell(row, column, ref allBoundsColumns);
 0809        }
 810
 811        public BoundsInt GetBoundsInt(int row, int column)
 0812        {
 0813            return GetCell(row, column, ref allBoundsIntColumns);
 0814        }
 815
 816        public Hash128 GetHash128(int row, int column)
 0817        {
 0818            return GetCell(row, column, ref allHash128Columns);
 0819        }
 820
 821        public Gradient GetGradient(int row, int column)
 0822        {
 0823            return GetCell(row, column, ref allGradientColumns);
 0824        }
 825
 826        public AnimationCurve GetAnimationCurve(int row, int column)
 0827        {
 0828            return GetCell(row, column, ref allAnimationCurveColumns);
 0829        }
 830
 831        public UnityEngine.Object GetObject(int row, int column)
 0832        {
 0833            return GetCell(row, column, ref allObjectRefColumns);
 0834        }
 835
 836        // Get ref
 837
 838        public ref string GetStringRef(int row, int column)
 0839        {
 0840            return ref GetCellRef(row, column, ref allStringColumns);
 0841        }
 842
 843        public ref bool GetBoolRef(int row, int column)
 0844        {
 0845            return ref GetCellRef(row, column, ref allBoolColumns);
 0846        }
 847
 848        public ref char GetCharRef(int row, int column)
 0849        {
 0850            return ref GetCellRef(row, column, ref allCharColumns);
 0851        }
 852
 853        public ref sbyte GetSbyteRef(int row, int column)
 0854        {
 0855            return ref GetCellRef(row, column, ref allSbyteColumns);
 0856        }
 857
 858        public ref byte GetByteRef(int row, int columnID)
 0859        {
 0860            return ref GetCellRef(row, columnID, ref allByteColumns);
 0861        }
 862
 863        public ref short GetShortRef(int row, int column)
 0864        {
 0865            return ref GetCellRef(row, column, ref allShortColumns);
 0866        }
 867
 868        public ref ushort GetUshortRef(int row, int column)
 0869        {
 0870            return ref GetCellRef(row, column, ref allUshortColumns);
 0871        }
 872
 873        public ref int GetIntRef(int row, int column)
 0874        {
 0875            return ref GetCellRef(row, column, ref allIntColumns);
 0876        }
 877
 878        public ref uint GetUintRef(int row, int column)
 0879        {
 0880            return ref GetCellRef(row, column, ref allUintColumns);
 0881        }
 882
 883        public ref long GetLongRef(int row, int column)
 0884        {
 0885            return ref GetCellRef(row, column, ref allLongColumns);
 0886        }
 887
 888        public ref ulong GetUlongRef(int row, int column)
 0889        {
 0890            return ref GetCellRef(row, column, ref allUlongColumns);
 0891        }
 892
 893        public ref float GetFloatRef(int row, int column)
 0894        {
 0895            return ref GetCellRef(row, column, ref allFloatColumns);
 0896        }
 897
 898        public ref double GetDoubleRef(int row, int column)
 0899        {
 0900            return ref GetCellRef(row, column, ref allDoubleColumns);
 0901        }
 902
 903        public ref Vector2 GetVector2Ref(int row, int column)
 0904        {
 0905            return ref GetCellRef(row, column, ref allVector2Columns);
 0906        }
 907
 908        public ref Vector3 GetVector3Ref(int row, int column)
 0909        {
 0910            return ref GetCellRef(row, column, ref allVector3Columns);
 0911        }
 912
 913        public ref Vector4 GetVector4Ref(int row, int column)
 0914        {
 0915            return ref GetCellRef(row, column, ref allVector4Columns);
 0916        }
 917
 918        public ref Vector2Int GetVector2IntRef(int row, int column)
 0919        {
 0920            return ref GetCellRef(row, column, ref allVector2IntColumns);
 0921        }
 922
 923        public ref Vector3Int GetVector3IntRef(int row, int column)
 0924        {
 0925            return ref GetCellRef(row, column, ref allVector3IntColumns);
 0926        }
 927
 928        public ref Quaternion GetQuaternionRef(int row, int column)
 0929        {
 0930            return ref GetCellRef(row, column, ref allQuaternionColumns);
 0931        }
 932
 933        public ref Rect GetRectRef(int row, int column)
 0934        {
 0935            return ref GetCellRef(row, column, ref allRectColumns);
 0936        }
 937
 938        public ref RectInt GetRectIntRef(int row, int column)
 0939        {
 0940            return ref GetCellRef(row, column, ref allRectIntColumns);
 0941        }
 942
 943        public ref Color GetColorRef(int row, int column)
 0944        {
 0945            return ref GetCellRef(row, column, ref allColorColumns);
 0946        }
 947
 948        public ref LayerMask GetLayerMaskRef(int row, int column)
 0949        {
 0950            return ref GetCellRef(row, column, ref allLayerMaskColumns);
 0951        }
 952
 953        public ref Bounds GetBoundsRef(int row, int column)
 0954        {
 0955            return ref GetCellRef(row, column, ref allBoundsColumns);
 0956        }
 957
 958        public ref BoundsInt GetBoundsIntRef(int row, int column)
 0959        {
 0960            return ref GetCellRef(row, column, ref allBoundsIntColumns);
 0961        }
 962
 963        public ref Hash128 GetHash128Ref(int row, int column)
 0964        {
 0965            return ref GetCellRef(row, column, ref allHash128Columns);
 0966        }
 967
 968        public ref Gradient GetGradientRef(int row, int column)
 0969        {
 0970            return ref GetCellRef(row, column, ref allGradientColumns);
 0971        }
 972
 973        public ref AnimationCurve GetAnimationCurveRef(int row, int column)
 0974        {
 0975            return ref GetCellRef(row, column, ref allAnimationCurveColumns);
 0976        }
 977
 978        public ref UnityEngine.Object GetObjectRef(int row, int column)
 0979        {
 0980            return ref GetCellRef(row, column, ref allObjectRefColumns);
 0981        }
 982
 983        // Get Column
 984
 985        public string[] GetStringColumn(int column)
 0986        {
 0987            return GetColumn(column, ref allStringColumns);
 0988        }
 989
 990        public bool[] GetBoolColumn(int column)
 0991        {
 0992            return GetColumn(column, ref allBoolColumns);
 0993        }
 994
 995        public char[] GetCharColumn(int column)
 0996        {
 0997            return GetColumn(column, ref allCharColumns);
 0998        }
 999
 1000        public sbyte[] GetSbyteColumn(int column)
 01001        {
 01002            return GetColumn(column, ref allSbyteColumns);
 01003        }
 1004
 1005        public byte[] GetByteColumn(int column)
 01006        {
 01007            return GetColumn(column, ref allByteColumns);
 01008        }
 1009
 1010        public short[] GetShortColumn(int column)
 01011        {
 01012            return GetColumn(column, ref allShortColumns);
 01013        }
 1014
 1015        public ushort[] GetUshortColumn(int column)
 01016        {
 01017            return GetColumn(column, ref allUshortColumns);
 01018        }
 1019
 1020        public int[] GetIntColumn(int column)
 01021        {
 01022            return GetColumn(column, ref allIntColumns);
 01023        }
 1024
 1025        public uint[] GetUintColumn(int column)
 01026        {
 01027            return GetColumn(column, ref allUintColumns);
 01028        }
 1029
 1030        public long[] GetLongColumn(int column)
 01031        {
 01032            return GetColumn(column, ref allLongColumns);
 01033        }
 1034
 1035        public ulong[] GetUlongColumn(int column)
 01036        {
 01037            return GetColumn(column, ref allUlongColumns);
 01038        }
 1039
 1040        public float[] GetFloatColumn(int column)
 01041        {
 01042            return GetColumn(column, ref allFloatColumns);
 01043        }
 1044
 1045        public double[] GetDoubleColumn(int column)
 01046        {
 01047            return GetColumn(column, ref allDoubleColumns);
 01048        }
 1049
 1050        public Vector2[] GetVector2Column(int column)
 01051        {
 01052            return GetColumn(column, ref allVector2Columns);
 01053        }
 1054
 1055        public Vector3[] GetVector3Column(int column)
 01056        {
 01057            return GetColumn(column, ref allVector3Columns);
 01058        }
 1059
 1060        public Vector4[] GetVector4Column(int column)
 01061        {
 01062            return GetColumn(column, ref allVector4Columns);
 01063        }
 1064
 1065        public Vector2Int[] GetVector2IntColumn(int column)
 01066        {
 01067            return GetColumn(column, ref allVector2IntColumns);
 01068        }
 1069
 1070        public Vector3Int[] GetVector3IntColumn(int column)
 01071        {
 01072            return GetColumn(column, ref allVector3IntColumns);
 01073        }
 1074
 1075        public Quaternion[] GetQuaternionColumn(int column)
 01076        {
 01077            return GetColumn(column, ref allQuaternionColumns);
 01078        }
 1079
 1080        public Rect[] GetRectColumn(int column)
 01081        {
 01082            return GetColumn(column, ref allRectColumns);
 01083        }
 1084
 1085        public RectInt[] GetRectIntColumn(int column)
 01086        {
 01087            return GetColumn(column, ref allRectIntColumns);
 01088        }
 1089
 1090        public Color[] GetColorColumn(int column)
 01091        {
 01092            return GetColumn(column, ref allColorColumns);
 01093        }
 1094
 1095        public LayerMask[] GetLayerMaskColumn(int column)
 01096        {
 01097            return GetColumn(column, ref allLayerMaskColumns);
 01098        }
 1099
 1100        public Bounds[] GetBoundsColumn(int column)
 01101        {
 01102            return GetColumn(column, ref allBoundsColumns);
 01103        }
 1104
 1105        public BoundsInt[] GetBoundsIntColumn(int column)
 01106        {
 01107            return GetColumn(column, ref allBoundsIntColumns);
 01108        }
 1109
 1110        public Hash128[] GetHash128Column(int column)
 01111        {
 01112            return GetColumn(column, ref allHash128Columns);
 01113        }
 1114
 1115        public Gradient[] GetGradientColumn(int column)
 01116        {
 01117            return GetColumn(column, ref allGradientColumns);
 01118        }
 1119
 1120        public AnimationCurve[] GetAnimationCurveColumn(int column)
 01121        {
 01122            return GetColumn(column, ref allAnimationCurveColumns);
 01123        }
 1124
 1125        public UnityEngine.Object[] GetObjectColumn(int column)
 01126        {
 01127            return GetColumn(column, ref allObjectRefColumns);
 01128        }
 1129
 1130        // Internal
 1131
 1132        internal int AddColumnInternal<T>(string columnName, ref ArrayHolder<T>[] allColumnsOfType, Serializable.Seriali
 01133        {
 01134            int columnCount = allColumnsOfType?.Length ?? 0;
 01135            Array.Resize(ref allColumnsOfType, columnCount + 1);
 01136            allColumnsOfType[columnCount].TArray = new T[rowCount];
 1137
 01138            string[] columnNamesForType = allColumnNames[(int)typeIndex].TArray;
 01139            int columnNamesCount = columnNamesForType?.Length ?? 0;
 01140            Array.Resize(ref columnNamesForType, columnNamesCount + 1);
 01141            columnNamesForType[columnNamesCount] = columnName;
 01142            allColumnNames[(int)typeIndex].TArray = columnNamesForType;
 1143
 01144            int columnIndex = columnEntriesFreeListHead;
 01145            int columnIDToDenseIndexMapLength = columnIDToDenseIndexMap?.Length ?? 0;
 01146            if (columnIndex >= columnIDToDenseIndexMapLength)
 01147            {
 01148                int newSize = columnIndex * 2;
 01149                newSize = newSize == 0 ? 1 : newSize;
 01150                Array.Resize(ref columnIDToDenseIndexMap, newSize);
 01151                for (int i = 0; i < columnIndex; i++)
 01152                {
 01153                    ref ColumnEntry entry = ref columnIDToDenseIndexMap[columnIndex + i];
 01154                    entry.columnDenseIndex = columnIndex + i + 1;
 01155                    entry.ColumnType = Serializable.SerializableTypes.Invalid;
 01156                }
 01157            }
 1158
 01159            ref int[] denseIndexToIDMap = ref columnDenseIndexToIDMap[(int)typeIndex].TArray;
 01160            int denseIndexToIDMapLength = denseIndexToIDMap?.Length ?? 0;
 01161            Array.Resize(ref denseIndexToIDMap, denseIndexToIDMapLength + 1);
 01162            denseIndexToIDMap[denseIndexToIDMapLength] = columnIndex;
 1163
 01164            ref ColumnEntry newEntry = ref columnIDToDenseIndexMap[columnIndex];
 01165            newEntry.columnDenseIndex = denseIndexToIDMapLength;
 01166            newEntry.ColumnType = typeIndex;
 1167
 01168            insertAt = insertAt < 0 ? combinedColumnCount : insertAt;
 01169            ref int[] columnOrdersOfType = ref allColumnOrders[(int)typeIndex].TArray;
 01170            int columnOrdersOfTypeLength = columnOrdersOfType?.Length ?? 0;
 01171            Array.Resize(ref columnOrdersOfType, columnOrdersOfTypeLength + 1);
 01172            columnOrdersOfType[columnOrdersOfTypeLength] = insertAt;
 1173
 01174            for (int i = 0; i < Serializable.SerializableTypesCount; i++)
 01175            {
 01176                int[] columnOrdersOfTypeCurrent = allColumnOrders[i].TArray;
 01177                int columnOrdersLength = columnOrdersOfTypeCurrent?.Length ?? 0;
 01178                for (int j = 0; j < columnOrdersLength; j++)
 01179                {
 01180                    int columnOrderCurrent = columnOrdersOfTypeCurrent[j];
 1181
 01182                    if (columnOrderCurrent > insertAt)
 01183                    {
 01184                        columnOrdersOfType[j] = columnOrderCurrent + 1;
 01185                    }
 01186                }
 01187            }
 1188
 01189            ++combinedColumnCount;
 01190            dataVersion++;
 1191
 01192            return columnIndex;
 01193        }
 1194
 1195        internal void RemoveColumnInternal<T>(ref ArrayHolder<T>[] allColumnsOfType, Serializable.SerializableTypes type
 01196        {
 01197            int columnLocation = columnIDToDenseIndexMap[column].columnDenseIndex;
 1198
 01199            int lastIndex = allColumnsOfType.Length - 1;
 01200            allColumnsOfType[columnLocation] = allColumnsOfType[lastIndex];
 1201           // T[][] newColumnArray = new T[lastIndex][];
 01202            ArrayHolder<T>[] newColumnArray = new ArrayHolder<T>[lastIndex];
 01203            Array.Copy(allColumnsOfType, 0, newColumnArray, 0, lastIndex);
 01204            allColumnsOfType = newColumnArray;
 1205
 01206            string[] columnNamesOfType = allColumnNames[(int)typeIndex].TArray;
 01207            columnNamesOfType[columnLocation] = columnNamesOfType[lastIndex];
 01208            string[] newColumnNamesOfType = new string[lastIndex];
 01209            Array.Copy(columnNamesOfType, 0, newColumnNamesOfType, 0, lastIndex);
 01210            allColumnNames[(int)typeIndex].TArray = newColumnNamesOfType;
 1211
 01212            int[] columnOrdersOfType = allColumnOrders[(int)typeIndex].TArray;
 01213            int columnOrder = columnOrdersOfType[columnLocation];
 01214            columnOrdersOfType[columnLocation] = columnOrdersOfType[lastIndex];
 01215            int[] newColumnOrdersOfType = new int[lastIndex];
 01216            Array.Copy(columnOrdersOfType, 0, newColumnOrdersOfType, 0, lastIndex);
 01217            allColumnOrders[(int)typeIndex].TArray = newColumnOrdersOfType;
 1218
 01219            int[] denseIndicesOfType = columnDenseIndexToIDMap[(int)typeIndex].TArray;
 01220            int sparseIndexAt = denseIndicesOfType[columnLocation];
 01221            int sparseIndexToSwap = columnOrdersOfType[lastIndex];
 01222            ref ColumnEntry sparseIndexToFree = ref columnIDToDenseIndexMap[sparseIndexAt];
 01223            sparseIndexToFree.ColumnType = Serializable.SerializableTypes.Invalid;
 01224            sparseIndexToFree.columnDenseIndex = columnEntriesFreeListHead;
 01225            columnEntriesFreeListHead = sparseIndexAt;
 01226            columnIDToDenseIndexMap[sparseIndexToSwap].columnDenseIndex = columnLocation;
 01227            denseIndicesOfType[columnLocation] = sparseIndexToSwap;
 01228            int[] newDenseIndicesOfType = new int[lastIndex];
 01229            Array.Copy(denseIndicesOfType, 0, newDenseIndicesOfType, 0, lastIndex);
 01230            columnDenseIndexToIDMap[(int)typeIndex].TArray = newDenseIndicesOfType;
 1231
 01232            for (int i = 0; i < Serializable.SerializableTypesCount; i++)
 01233            {
 01234                int[] columnOrdersOfTypeCurrent = allColumnOrders[i].TArray;
 1235
 01236                int columnOrdersLength = columnOrdersOfTypeCurrent.Length;
 01237                for (int j = 0; j < columnOrdersLength; j++)
 01238                {
 01239                    int columnOrderCurrent = columnOrdersOfTypeCurrent[j];
 1240
 01241                    if (columnOrderCurrent > columnOrder)
 01242                    {
 01243                        columnOrdersOfType[j] = columnOrderCurrent - 1;
 01244                    }
 01245                }
 01246            }
 1247
 01248            --combinedColumnCount;
 01249            dataVersion++;
 01250        }
 1251
 1252        internal void InsertRowsOfTypeInternal<T>(ref ArrayHolder<T>[] allColumnsOfType, int insertAt, int numberOfNewRo
 01253        {
 01254            int columnCount = allColumnsOfType?.Length ?? 0;
 01255            for (int i = 0; i < columnCount; i++)
 01256            {
 01257                ref T[] column = ref allColumnsOfType[i].TArray;
 01258                int newRowCount = rowCount + numberOfNewRows;
 01259                Array.Resize(ref column, newRowCount);
 01260                for (int j = newRowCount - 1; j > insertAt + numberOfNewRows - 1; j--)
 01261                {
 01262                    column[j] = column[j - numberOfNewRows];
 01263                }
 1264
 01265                for (int j = 0; j < numberOfNewRows; j++)
 01266                {
 01267                    column[insertAt + j] = default;
 01268                }
 01269            }
 01270        }
 1271
 1272        internal void DeleteRowsOfTypeInternal<T>(ref ArrayHolder<T>[] allColumnsOfType, int removeAt, int numberOfRowsT
 01273        {
 01274            int columnCount = allColumnsOfType?.Length ?? 0;
 1275
 01276            for (int i = 0; i < columnCount; i++)
 01277            {
 01278                ref T[] column = ref allColumnsOfType[i].TArray;
 01279                int newRowCount = rowCount - numberOfRowsToDelete;
 1280
 01281                for (int j = removeAt; j < rowCount - numberOfRowsToDelete; j++)
 01282                {
 01283                    column[j] = column[j + numberOfRowsToDelete];
 01284                }
 1285
 01286                Array.Resize(ref column, newRowCount);
 01287            }
 01288        }
 1289
 1290        internal ref T GetCellRef<T>(int rowID, int columnID, ref ArrayHolder<T>[] allColumnsOfType)
 01291        {
 01292            int column = columnIDToDenseIndexMap[columnID].columnDenseIndex;
 01293            return ref allColumnsOfType[column][rowID];
 01294        }
 1295
 1296        internal T GetCell<T>(int rowID, int columnID, ref ArrayHolder<T>[] allColumnsOfType)
 01297        {
 01298            int column = columnIDToDenseIndexMap[columnID].columnDenseIndex;
 01299            return allColumnsOfType[column][rowID];
 01300        }
 1301
 1302        internal ulong SetCell<T>(int rowID, int columnID, ref ArrayHolder<T>[] allColumnsOfType, T value)
 01303        {
 01304            int column = columnIDToDenseIndexMap[columnID].columnDenseIndex;
 01305            allColumnsOfType[column][rowID] = value;
 01306            dataVersion++;
 01307            return dataVersion;
 01308        }
 1309
 1310        internal T[] GetColumn<T>(int columnID, ref ArrayHolder<T>[] allColumnsOfType)
 01311        {
 01312            int column = columnIDToDenseIndexMap[columnID].columnDenseIndex;
 01313            return allColumnsOfType[column].TArray;
 01314        }
 1315    }
 1316}
Generated by: ReportGenerator 5.0.4.0
2023-05-20 - 11:00:46 PM
GitHub | www.palmmedia.de

Coverage by test methods





































































































































































































































































































































































































































































































































































































































































































Methods/Properties

StableTable()
GetDataVersion()
GetColumnCount()
GetRowCount()
GetAllRowDescriptions()
GetRowDescription(System.String)
GetRowDescription(System.Int32)
GetColumnDescription(System.String)
GetColumnDescription(System.Int32)
GetAllColumnDescriptions()
SetColumnName(System.String, System.Int32)
AddRow(System.String, System.Int32)
AddRows(System.Int32, System.String[], System.Int32)
RemoveRow(System.Int32)
RemoveRows(System.Int32, System.Int32)
AddColumn(GDX.Serializable/SerializableTypes, System.String, System.Int32)
RemoveColumn(GDX.Serializable/SerializableTypes, System.Int32)
SetString(System.Int32, System.Int32, System.String)
SetBool(System.Int32, System.Int32, System.Boolean)
SetChar(System.Int32, System.Int32, System.Char)
SetSByte(System.Int32, System.Int32, System.SByte)
SetByte(System.Int32, System.Int32, System.Byte)
SetShort(System.Int32, System.Int32, System.Int16)
SetUShort(System.Int32, System.Int32, System.UInt16)
SetInt(System.Int32, System.Int32, System.Int32)
SetUInt(System.Int32, System.Int32, System.UInt32)
SetLong(System.Int32, System.Int32, System.Int64)
SetULong(System.Int32, System.Int32, System.UInt64)
SetFloat(System.Int32, System.Int32, System.Single)
SetDouble(System.Int32, System.Int32, System.Double)
SetVector2(System.Int32, System.Int32, UnityEngine.Vector2)
SetVector3(System.Int32, System.Int32, UnityEngine.Vector3)
SetVector4(System.Int32, System.Int32, UnityEngine.Vector4)
SetVector2Int(System.Int32, System.Int32, UnityEngine.Vector2Int)
SetVector3Int(System.Int32, System.Int32, UnityEngine.Vector3Int)
SetQuaternion(System.Int32, System.Int32, UnityEngine.Quaternion)
SetRect(System.Int32, System.Int32, UnityEngine.Rect)
SetRectInt(System.Int32, System.Int32, UnityEngine.RectInt)
SetColor(System.Int32, System.Int32, UnityEngine.Color)
SetLayerMask(System.Int32, System.Int32, UnityEngine.LayerMask)
SetBounds(System.Int32, System.Int32, UnityEngine.Bounds)
SetBoundsInt(System.Int32, System.Int32, UnityEngine.BoundsInt)
SetHash128(System.Int32, System.Int32, UnityEngine.Hash128)
SetGradient(System.Int32, System.Int32, UnityEngine.Gradient)
SetAnimationCurve(System.Int32, System.Int32, UnityEngine.AnimationCurve)
SetObject(System.Int32, System.Int32, UnityEngine.Object)
GetString(System.Int32, System.Int32)
GetBool(System.Int32, System.Int32)
GetChar(System.Int32, System.Int32)
GetSByte(System.Int32, System.Int32)
GetByte(System.Int32, System.Int32)
GetShort(System.Int32, System.Int32)
GetUShort(System.Int32, System.Int32)
GetInt(System.Int32, System.Int32)
GetUInt(System.Int32, System.Int32)
GetLong(System.Int32, System.Int32)
GetULong(System.Int32, System.Int32)
GetFloat(System.Int32, System.Int32)
GetDouble(System.Int32, System.Int32)
GetVector2(System.Int32, System.Int32)
GetVector3(System.Int32, System.Int32)
GetVector4(System.Int32, System.Int32)
GetVector2Int(System.Int32, System.Int32)
GetVector3Int(System.Int32, System.Int32)
GetQuaternion(System.Int32, System.Int32)
GetRect(System.Int32, System.Int32)
GetRectInt(System.Int32, System.Int32)
GetColor(System.Int32, System.Int32)
GetLayerMask(System.Int32, System.Int32)
GetBounds(System.Int32, System.Int32)
GetBoundsInt(System.Int32, System.Int32)
GetHash128(System.Int32, System.Int32)
GetGradient(System.Int32, System.Int32)
GetAnimationCurve(System.Int32, System.Int32)
GetObject(System.Int32, System.Int32)
GetStringRef(System.Int32, System.Int32)
GetBoolRef(System.Int32, System.Int32)
GetCharRef(System.Int32, System.Int32)
GetSbyteRef(System.Int32, System.Int32)
GetByteRef(System.Int32, System.Int32)
GetShortRef(System.Int32, System.Int32)
GetUshortRef(System.Int32, System.Int32)
GetIntRef(System.Int32, System.Int32)
GetUintRef(System.Int32, System.Int32)
GetLongRef(System.Int32, System.Int32)
GetUlongRef(System.Int32, System.Int32)
GetFloatRef(System.Int32, System.Int32)
GetDoubleRef(System.Int32, System.Int32)
GetVector2Ref(System.Int32, System.Int32)
GetVector3Ref(System.Int32, System.Int32)
GetVector4Ref(System.Int32, System.Int32)
GetVector2IntRef(System.Int32, System.Int32)
GetVector3IntRef(System.Int32, System.Int32)
GetQuaternionRef(System.Int32, System.Int32)
GetRectRef(System.Int32, System.Int32)
GetRectIntRef(System.Int32, System.Int32)
GetColorRef(System.Int32, System.Int32)
GetLayerMaskRef(System.Int32, System.Int32)
GetBoundsRef(System.Int32, System.Int32)
GetBoundsIntRef(System.Int32, System.Int32)
GetHash128Ref(System.Int32, System.Int32)
GetGradientRef(System.Int32, System.Int32)
GetAnimationCurveRef(System.Int32, System.Int32)
GetObjectRef(System.Int32, System.Int32)
GetStringColumn(System.Int32)
GetBoolColumn(System.Int32)
GetCharColumn(System.Int32)
GetSbyteColumn(System.Int32)
GetByteColumn(System.Int32)
GetShortColumn(System.Int32)
GetUshortColumn(System.Int32)
GetIntColumn(System.Int32)
GetUintColumn(System.Int32)
GetLongColumn(System.Int32)
GetUlongColumn(System.Int32)
GetFloatColumn(System.Int32)
GetDoubleColumn(System.Int32)
GetVector2Column(System.Int32)
GetVector3Column(System.Int32)
GetVector4Column(System.Int32)
GetVector2IntColumn(System.Int32)
GetVector3IntColumn(System.Int32)
GetQuaternionColumn(System.Int32)
GetRectColumn(System.Int32)
GetRectIntColumn(System.Int32)
GetColorColumn(System.Int32)
GetLayerMaskColumn(System.Int32)
GetBoundsColumn(System.Int32)
GetBoundsIntColumn(System.Int32)
GetHash128Column(System.Int32)
GetGradientColumn(System.Int32)
GetAnimationCurveColumn(System.Int32)
GetObjectColumn(System.Int32)
AddColumnInternal[T](System.String, , GDX.Serializable/SerializableTypes, System.Int32)
RemoveColumnInternal[T](, GDX.Serializable/SerializableTypes, System.Int32)
InsertRowsOfTypeInternal[T](, System.Int32, System.Int32)
DeleteRowsOfTypeInternal[T](, System.Int32, System.Int32)
GetCellRef[T](System.Int32, System.Int32, )
GetCell[T](System.Int32, System.Int32, )
SetCell[T](System.Int32, System.Int32, , T)
GetColumn[T](System.Int32, )